/*
循环引用：
 A -> B
 ↑    ↓
 B <- A

Weak 是 Rust 中与 Rc（引用计数指针）配合使用的一种智能指针，用于解决循环引用导致的内存泄漏问题。

Weak（弱引用）是一种不拥有所有权的智能指针，它不会增加引用计数，因此不会阻止值的清理。


Rc/Arc：强引用，增加引用计数，所有权关系

Weak：弱引用，不增加引用计数，非所有权关系

Weak 的方法
upgrade() -> Option<Rc<T>> / Option<Arc<T>>：尝试升级为强引用

new() -> Weak<T>：创建新的空 Weak 引用


Rc/Arc 的方法
downgrade(&self) -> Weak<T>：创建弱引用

weak_count(&self) -> usize：获取弱引用计数

strong_count(&self) -> usize：获取强引用计数



总结：
在可能存在循环引用的数据结构使用weak 打破 循环引用异常，由此引出一个问题， 为啥 weak 可以打破 引用异常 远程是 ，weak 一个指向目标内存但不拥有内存所有权的智能指针
并且它也没有引用计数的特征，所以 在内存值被释放回收后 他仍然可以使用（值为 none）


*/

use std::cell::RefCell;
use std::clone;
use std::fmt::Display;
use std::rc::{Rc, Weak};
#[derive(Debug)]
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,
    children: RefCell<Vec<Rc<Node>>>,
}

pub fn run1() {
    let leaf = Rc::new(Node {
        value: 3,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });

    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());

    let branch = Rc::new(Node {
        value: 5,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![Rc::clone(&leaf)]),
    });

    *leaf.parent.borrow_mut() = Rc::downgrade(&branch);

    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
}

#[derive(Debug)]
struct ListNode {
    value: i32,
    next: RefCell<Option<Rc<ListNode>>>,
    prev: RefCell<Weak<ListNode>>,
}

impl ListNode {
    fn new(value: i32) -> Rc<Self> {
        Rc::new(ListNode {
            value,
            next: RefCell::new(None),
            prev: RefCell::new(Weak::new()),
        })
    }
}

//双向链表示例
pub fn run2() {
    let node1 = ListNode::new(1);
    let node2 = ListNode::new(2);

    // 建立双向链接
    *node1.next.borrow_mut() = Some(Rc::clone(&node2));
    *node2.prev.borrow_mut() = Rc::downgrade(&node1);

    println!("Node1: {:?}", node1.value);
    if let Some(next) = &*node1.next.borrow() {
        println!("Node1 next: {:?}", next.value);
    }

    if let Some(prev) = node2.prev.borrow().upgrade() {
        println!("Node2 prev: {:?}", prev.value);
    }
}

#[derive(Debug)]
struct TreeNode {
    name: String,
    children: RefCell<Vec<Rc<TreeNode>>>,
    parent: RefCell<Weak<TreeNode>>,
}

impl TreeNode {
    fn new(name: &str) -> Rc<Self> {
        Rc::new(TreeNode {
            name: name.to_string(),
            children: RefCell::new(vec![]),
            parent: RefCell::new(Weak::new()),
        })
    }

    fn add_child(parent: &Rc<TreeNode>, child: &Rc<TreeNode>) {
        parent.children.borrow_mut().push(Rc::clone(child));
        *child.parent.borrow_mut() = Rc::downgrade(parent);
    }
}

//树形结构中的循环引用
pub fn run3() {
    let root = TreeNode::new("root");
    let child1 = TreeNode::new("child1");
    let child2 = TreeNode::new("child2");

    TreeNode::add_child(&root, &child1);
    TreeNode::add_child(&root, &child2);

    // 打印树结构
    print_tree(&root, 0);
}

fn print_tree(node: &TreeNode, level: usize) {
    let indent = "  ".repeat(level);
    println!("{}{}", indent, node.name);

    for child in node.children.borrow().iter() {
        print_tree(child, level + 1);
    }
}

#[derive(Debug)]
struct MemoryLeak {
    data: String,
    partner: RefCell<Option<Rc<MemoryLeak>>>,
}

struct MemoryLeak_pro {
    data: String,
    partner: RefCell<Weak<MemoryLeak>>,
}
//内存泄漏例子
fn run4() {
    let a = Rc::new(MemoryLeak {
        data: "A".to_string(),
        partner: RefCell::new(None),
    });

    let b = Rc::new(MemoryLeak {
        data: "B".to_string(),
        partner: RefCell::new(None),
    });

    // 创建循环引用 - 这将导致内存泄漏！
    *a.partner.borrow_mut() = Some(Rc::clone(&b));
    *b.partner.borrow_mut() = Some(Rc::clone(&a));

    println!("Created cycle between A and B");
    // a 和 b 将永远不会被释放，即使离开作用域
}



pub fn Run() {
    run1();
    run2();
    run3();
}
